# -*- coding: utf-8 -*-
"""
Tencent is pleased to support the open source community by making 蓝鲸智云PaaS平台社区版 (BlueKing PaaS
Community Edition) available.
Copyright (C) 2017-2018 THL A29 Limited, a Tencent company. All rights reserved.
Licensed under the MIT License (the "License"); you may not use this file except in compliance with the License.
You may obtain a copy of the License at http://opensource.org/licenses/MIT
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
"""

#
# Autogenerated by Thrift Compiler (0.10.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
#  options string: py
#

from thrift.Thrift import TType, TMessageType, TFrozenDict, TException, TApplicationException
from thrift.protocol.TProtocol import TProtocolException
import sys
import logging
from .ttypes import *
from thrift.Thrift import TProcessor
from thrift.transport import TTransport


class Iface(object):
    def quireBusinessInfo(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireIpInfo(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireProcInfo(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireSystem(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireCpu(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireMem(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireNet(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireDisk(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireDiskUsed(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireProcess(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireLocalInfo(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireArch(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireCroud(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireIpTable(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireAlarm(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireAllProc(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireAllPort(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireMultiInfos(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireHistoryCpu(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireHistoryMem(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireHistoryNet(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireHistoryDisk(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireHistoryDiskUsed(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireHistoryProcess(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireHistoryLocalInfo(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireHistoryArch(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireHistoryCroud(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireHistoryIpTable(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireHistoryAlarm(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireHistoryAllProc(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireHistoryAllPort(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireLostAgentInfo(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireAgentStatus(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def quireAllIp(self):
        pass

    def quireMultiIp(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def flushAgentInfo(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        pass

    def get_agent_status(self, request_info):
        """
        Parameters:
         - request_info
        """
        pass

    def get_agent_info(self, request_info):
        """
        Parameters:
         - request_info
        """
        pass


class Client(Iface):
    def __init__(self, iprot, oprot=None):
        self._iprot = self._oprot = iprot
        if oprot is not None:
            self._oprot = oprot
        self._seqid = 0

    def quireBusinessInfo(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireBusinessInfo(requestInfo)
        return self.recv_quireBusinessInfo()

    def send_quireBusinessInfo(self, requestInfo):
        self._oprot.writeMessageBegin("quireBusinessInfo", TMessageType.CALL, self._seqid)
        args = quireBusinessInfo_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireBusinessInfo(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireBusinessInfo_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireBusinessInfo failed: unknown result")

    def quireIpInfo(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireIpInfo(requestInfo)
        return self.recv_quireIpInfo()

    def send_quireIpInfo(self, requestInfo):
        self._oprot.writeMessageBegin("quireIpInfo", TMessageType.CALL, self._seqid)
        args = quireIpInfo_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireIpInfo(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireIpInfo_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireIpInfo failed: unknown result")

    def quireProcInfo(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireProcInfo(requestInfo)
        return self.recv_quireProcInfo()

    def send_quireProcInfo(self, requestInfo):
        self._oprot.writeMessageBegin("quireProcInfo", TMessageType.CALL, self._seqid)
        args = quireProcInfo_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireProcInfo(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireProcInfo_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireProcInfo failed: unknown result")

    def quireSystem(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireSystem(requestInfo)
        return self.recv_quireSystem()

    def send_quireSystem(self, requestInfo):
        self._oprot.writeMessageBegin("quireSystem", TMessageType.CALL, self._seqid)
        args = quireSystem_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireSystem(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireSystem_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireSystem failed: unknown result")

    def quireCpu(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireCpu(requestInfo)
        return self.recv_quireCpu()

    def send_quireCpu(self, requestInfo):
        self._oprot.writeMessageBegin("quireCpu", TMessageType.CALL, self._seqid)
        args = quireCpu_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireCpu(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireCpu_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireCpu failed: unknown result")

    def quireMem(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireMem(requestInfo)
        return self.recv_quireMem()

    def send_quireMem(self, requestInfo):
        self._oprot.writeMessageBegin("quireMem", TMessageType.CALL, self._seqid)
        args = quireMem_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireMem(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireMem_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireMem failed: unknown result")

    def quireNet(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireNet(requestInfo)
        return self.recv_quireNet()

    def send_quireNet(self, requestInfo):
        self._oprot.writeMessageBegin("quireNet", TMessageType.CALL, self._seqid)
        args = quireNet_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireNet(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireNet_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireNet failed: unknown result")

    def quireDisk(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireDisk(requestInfo)
        return self.recv_quireDisk()

    def send_quireDisk(self, requestInfo):
        self._oprot.writeMessageBegin("quireDisk", TMessageType.CALL, self._seqid)
        args = quireDisk_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireDisk(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireDisk_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireDisk failed: unknown result")

    def quireDiskUsed(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireDiskUsed(requestInfo)
        return self.recv_quireDiskUsed()

    def send_quireDiskUsed(self, requestInfo):
        self._oprot.writeMessageBegin("quireDiskUsed", TMessageType.CALL, self._seqid)
        args = quireDiskUsed_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireDiskUsed(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireDiskUsed_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireDiskUsed failed: unknown result")

    def quireProcess(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireProcess(requestInfo)
        return self.recv_quireProcess()

    def send_quireProcess(self, requestInfo):
        self._oprot.writeMessageBegin("quireProcess", TMessageType.CALL, self._seqid)
        args = quireProcess_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireProcess(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireProcess_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireProcess failed: unknown result")

    def quireLocalInfo(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireLocalInfo(requestInfo)
        return self.recv_quireLocalInfo()

    def send_quireLocalInfo(self, requestInfo):
        self._oprot.writeMessageBegin("quireLocalInfo", TMessageType.CALL, self._seqid)
        args = quireLocalInfo_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireLocalInfo(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireLocalInfo_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireLocalInfo failed: unknown result")

    def quireArch(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireArch(requestInfo)
        return self.recv_quireArch()

    def send_quireArch(self, requestInfo):
        self._oprot.writeMessageBegin("quireArch", TMessageType.CALL, self._seqid)
        args = quireArch_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireArch(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireArch_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireArch failed: unknown result")

    def quireCroud(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireCroud(requestInfo)
        return self.recv_quireCroud()

    def send_quireCroud(self, requestInfo):
        self._oprot.writeMessageBegin("quireCroud", TMessageType.CALL, self._seqid)
        args = quireCroud_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireCroud(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireCroud_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireCroud failed: unknown result")

    def quireIpTable(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireIpTable(requestInfo)
        return self.recv_quireIpTable()

    def send_quireIpTable(self, requestInfo):
        self._oprot.writeMessageBegin("quireIpTable", TMessageType.CALL, self._seqid)
        args = quireIpTable_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireIpTable(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireIpTable_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireIpTable failed: unknown result")

    def quireAlarm(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireAlarm(requestInfo)
        return self.recv_quireAlarm()

    def send_quireAlarm(self, requestInfo):
        self._oprot.writeMessageBegin("quireAlarm", TMessageType.CALL, self._seqid)
        args = quireAlarm_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireAlarm(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireAlarm_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireAlarm failed: unknown result")

    def quireAllProc(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireAllProc(requestInfo)
        return self.recv_quireAllProc()

    def send_quireAllProc(self, requestInfo):
        self._oprot.writeMessageBegin("quireAllProc", TMessageType.CALL, self._seqid)
        args = quireAllProc_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireAllProc(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireAllProc_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireAllProc failed: unknown result")

    def quireAllPort(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireAllPort(requestInfo)
        return self.recv_quireAllPort()

    def send_quireAllPort(self, requestInfo):
        self._oprot.writeMessageBegin("quireAllPort", TMessageType.CALL, self._seqid)
        args = quireAllPort_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireAllPort(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireAllPort_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireAllPort failed: unknown result")

    def quireMultiInfos(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireMultiInfos(requestInfo)
        return self.recv_quireMultiInfos()

    def send_quireMultiInfos(self, requestInfo):
        self._oprot.writeMessageBegin("quireMultiInfos", TMessageType.CALL, self._seqid)
        args = quireMultiInfos_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireMultiInfos(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireMultiInfos_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireMultiInfos failed: unknown result")

    def quireHistoryCpu(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireHistoryCpu(requestInfo)
        return self.recv_quireHistoryCpu()

    def send_quireHistoryCpu(self, requestInfo):
        self._oprot.writeMessageBegin("quireHistoryCpu", TMessageType.CALL, self._seqid)
        args = quireHistoryCpu_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireHistoryCpu(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireHistoryCpu_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireHistoryCpu failed: unknown result")

    def quireHistoryMem(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireHistoryMem(requestInfo)
        return self.recv_quireHistoryMem()

    def send_quireHistoryMem(self, requestInfo):
        self._oprot.writeMessageBegin("quireHistoryMem", TMessageType.CALL, self._seqid)
        args = quireHistoryMem_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireHistoryMem(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireHistoryMem_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireHistoryMem failed: unknown result")

    def quireHistoryNet(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireHistoryNet(requestInfo)
        return self.recv_quireHistoryNet()

    def send_quireHistoryNet(self, requestInfo):
        self._oprot.writeMessageBegin("quireHistoryNet", TMessageType.CALL, self._seqid)
        args = quireHistoryNet_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireHistoryNet(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireHistoryNet_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireHistoryNet failed: unknown result")

    def quireHistoryDisk(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireHistoryDisk(requestInfo)
        return self.recv_quireHistoryDisk()

    def send_quireHistoryDisk(self, requestInfo):
        self._oprot.writeMessageBegin("quireHistoryDisk", TMessageType.CALL, self._seqid)
        args = quireHistoryDisk_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireHistoryDisk(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireHistoryDisk_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireHistoryDisk failed: unknown result")

    def quireHistoryDiskUsed(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireHistoryDiskUsed(requestInfo)
        return self.recv_quireHistoryDiskUsed()

    def send_quireHistoryDiskUsed(self, requestInfo):
        self._oprot.writeMessageBegin("quireHistoryDiskUsed", TMessageType.CALL, self._seqid)
        args = quireHistoryDiskUsed_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireHistoryDiskUsed(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireHistoryDiskUsed_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(
            TApplicationException.MISSING_RESULT, "quireHistoryDiskUsed failed: unknown result"
        )

    def quireHistoryProcess(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireHistoryProcess(requestInfo)
        return self.recv_quireHistoryProcess()

    def send_quireHistoryProcess(self, requestInfo):
        self._oprot.writeMessageBegin("quireHistoryProcess", TMessageType.CALL, self._seqid)
        args = quireHistoryProcess_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireHistoryProcess(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireHistoryProcess_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireHistoryProcess failed: unknown result")

    def quireHistoryLocalInfo(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireHistoryLocalInfo(requestInfo)
        return self.recv_quireHistoryLocalInfo()

    def send_quireHistoryLocalInfo(self, requestInfo):
        self._oprot.writeMessageBegin("quireHistoryLocalInfo", TMessageType.CALL, self._seqid)
        args = quireHistoryLocalInfo_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireHistoryLocalInfo(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireHistoryLocalInfo_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(
            TApplicationException.MISSING_RESULT, "quireHistoryLocalInfo failed: unknown result"
        )

    def quireHistoryArch(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireHistoryArch(requestInfo)
        return self.recv_quireHistoryArch()

    def send_quireHistoryArch(self, requestInfo):
        self._oprot.writeMessageBegin("quireHistoryArch", TMessageType.CALL, self._seqid)
        args = quireHistoryArch_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireHistoryArch(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireHistoryArch_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireHistoryArch failed: unknown result")

    def quireHistoryCroud(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireHistoryCroud(requestInfo)
        return self.recv_quireHistoryCroud()

    def send_quireHistoryCroud(self, requestInfo):
        self._oprot.writeMessageBegin("quireHistoryCroud", TMessageType.CALL, self._seqid)
        args = quireHistoryCroud_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireHistoryCroud(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireHistoryCroud_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireHistoryCroud failed: unknown result")

    def quireHistoryIpTable(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireHistoryIpTable(requestInfo)
        return self.recv_quireHistoryIpTable()

    def send_quireHistoryIpTable(self, requestInfo):
        self._oprot.writeMessageBegin("quireHistoryIpTable", TMessageType.CALL, self._seqid)
        args = quireHistoryIpTable_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireHistoryIpTable(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireHistoryIpTable_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireHistoryIpTable failed: unknown result")

    def quireHistoryAlarm(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireHistoryAlarm(requestInfo)
        return self.recv_quireHistoryAlarm()

    def send_quireHistoryAlarm(self, requestInfo):
        self._oprot.writeMessageBegin("quireHistoryAlarm", TMessageType.CALL, self._seqid)
        args = quireHistoryAlarm_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireHistoryAlarm(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireHistoryAlarm_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireHistoryAlarm failed: unknown result")

    def quireHistoryAllProc(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireHistoryAllProc(requestInfo)
        return self.recv_quireHistoryAllProc()

    def send_quireHistoryAllProc(self, requestInfo):
        self._oprot.writeMessageBegin("quireHistoryAllProc", TMessageType.CALL, self._seqid)
        args = quireHistoryAllProc_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireHistoryAllProc(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireHistoryAllProc_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireHistoryAllProc failed: unknown result")

    def quireHistoryAllPort(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireHistoryAllPort(requestInfo)
        return self.recv_quireHistoryAllPort()

    def send_quireHistoryAllPort(self, requestInfo):
        self._oprot.writeMessageBegin("quireHistoryAllPort", TMessageType.CALL, self._seqid)
        args = quireHistoryAllPort_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireHistoryAllPort(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireHistoryAllPort_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireHistoryAllPort failed: unknown result")

    def quireLostAgentInfo(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireLostAgentInfo(requestInfo)
        return self.recv_quireLostAgentInfo()

    def send_quireLostAgentInfo(self, requestInfo):
        self._oprot.writeMessageBegin("quireLostAgentInfo", TMessageType.CALL, self._seqid)
        args = quireLostAgentInfo_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireLostAgentInfo(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireLostAgentInfo_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireLostAgentInfo failed: unknown result")

    def quireAgentStatus(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireAgentStatus(requestInfo)
        return self.recv_quireAgentStatus()

    def send_quireAgentStatus(self, requestInfo):
        self._oprot.writeMessageBegin("quireAgentStatus", TMessageType.CALL, self._seqid)
        args = quireAgentStatus_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireAgentStatus(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireAgentStatus_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireAgentStatus failed: unknown result")

    def quireAllIp(self):
        self.send_quireAllIp()
        return self.recv_quireAllIp()

    def send_quireAllIp(self):
        self._oprot.writeMessageBegin("quireAllIp", TMessageType.CALL, self._seqid)
        args = quireAllIp_args()
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireAllIp(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireAllIp_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireAllIp failed: unknown result")

    def quireMultiIp(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_quireMultiIp(requestInfo)
        return self.recv_quireMultiIp()

    def send_quireMultiIp(self, requestInfo):
        self._oprot.writeMessageBegin("quireMultiIp", TMessageType.CALL, self._seqid)
        args = quireMultiIp_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_quireMultiIp(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = quireMultiIp_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "quireMultiIp failed: unknown result")

    def flushAgentInfo(self, requestInfo):
        """
        Parameters:
         - requestInfo
        """
        self.send_flushAgentInfo(requestInfo)
        return self.recv_flushAgentInfo()

    def send_flushAgentInfo(self, requestInfo):
        self._oprot.writeMessageBegin("flushAgentInfo", TMessageType.CALL, self._seqid)
        args = flushAgentInfo_args()
        args.requestInfo = requestInfo
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_flushAgentInfo(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = flushAgentInfo_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "flushAgentInfo failed: unknown result")

    def get_agent_status(self, request_info):
        """
        Parameters:
         - request_info
        """
        self.send_get_agent_status(request_info)
        return self.recv_get_agent_status()

    def send_get_agent_status(self, request_info):
        self._oprot.writeMessageBegin("get_agent_status", TMessageType.CALL, self._seqid)
        args = get_agent_status_args()
        args.request_info = request_info
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_agent_status(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_agent_status_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_agent_status failed: unknown result")

    def get_agent_info(self, request_info):
        """
        Parameters:
         - request_info
        """
        self.send_get_agent_info(request_info)
        return self.recv_get_agent_info()

    def send_get_agent_info(self, request_info):
        self._oprot.writeMessageBegin("get_agent_info", TMessageType.CALL, self._seqid)
        args = get_agent_info_args()
        args.request_info = request_info
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_agent_info(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_agent_info_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_agent_info failed: unknown result")


class Processor(Iface, TProcessor):
    def __init__(self, handler):
        self._handler = handler
        self._processMap = {}
        self._processMap["quireBusinessInfo"] = Processor.process_quireBusinessInfo
        self._processMap["quireIpInfo"] = Processor.process_quireIpInfo
        self._processMap["quireProcInfo"] = Processor.process_quireProcInfo
        self._processMap["quireSystem"] = Processor.process_quireSystem
        self._processMap["quireCpu"] = Processor.process_quireCpu
        self._processMap["quireMem"] = Processor.process_quireMem
        self._processMap["quireNet"] = Processor.process_quireNet
        self._processMap["quireDisk"] = Processor.process_quireDisk
        self._processMap["quireDiskUsed"] = Processor.process_quireDiskUsed
        self._processMap["quireProcess"] = Processor.process_quireProcess
        self._processMap["quireLocalInfo"] = Processor.process_quireLocalInfo
        self._processMap["quireArch"] = Processor.process_quireArch
        self._processMap["quireCroud"] = Processor.process_quireCroud
        self._processMap["quireIpTable"] = Processor.process_quireIpTable
        self._processMap["quireAlarm"] = Processor.process_quireAlarm
        self._processMap["quireAllProc"] = Processor.process_quireAllProc
        self._processMap["quireAllPort"] = Processor.process_quireAllPort
        self._processMap["quireMultiInfos"] = Processor.process_quireMultiInfos
        self._processMap["quireHistoryCpu"] = Processor.process_quireHistoryCpu
        self._processMap["quireHistoryMem"] = Processor.process_quireHistoryMem
        self._processMap["quireHistoryNet"] = Processor.process_quireHistoryNet
        self._processMap["quireHistoryDisk"] = Processor.process_quireHistoryDisk
        self._processMap["quireHistoryDiskUsed"] = Processor.process_quireHistoryDiskUsed
        self._processMap["quireHistoryProcess"] = Processor.process_quireHistoryProcess
        self._processMap["quireHistoryLocalInfo"] = Processor.process_quireHistoryLocalInfo
        self._processMap["quireHistoryArch"] = Processor.process_quireHistoryArch
        self._processMap["quireHistoryCroud"] = Processor.process_quireHistoryCroud
        self._processMap["quireHistoryIpTable"] = Processor.process_quireHistoryIpTable
        self._processMap["quireHistoryAlarm"] = Processor.process_quireHistoryAlarm
        self._processMap["quireHistoryAllProc"] = Processor.process_quireHistoryAllProc
        self._processMap["quireHistoryAllPort"] = Processor.process_quireHistoryAllPort
        self._processMap["quireLostAgentInfo"] = Processor.process_quireLostAgentInfo
        self._processMap["quireAgentStatus"] = Processor.process_quireAgentStatus
        self._processMap["quireAllIp"] = Processor.process_quireAllIp
        self._processMap["quireMultiIp"] = Processor.process_quireMultiIp
        self._processMap["flushAgentInfo"] = Processor.process_flushAgentInfo
        self._processMap["get_agent_status"] = Processor.process_get_agent_status
        self._processMap["get_agent_info"] = Processor.process_get_agent_info

    def process(self, iprot, oprot):
        (name, type, seqid) = iprot.readMessageBegin()
        if name not in self._processMap:
            iprot.skip(TType.STRUCT)
            iprot.readMessageEnd()
            x = TApplicationException(TApplicationException.UNKNOWN_METHOD, "Unknown function %s" % (name))
            oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
            x.write(oprot)
            oprot.writeMessageEnd()
            oprot.trans.flush()
            return
        else:
            self._processMap[name](self, seqid, iprot, oprot)
        return True

    def process_quireBusinessInfo(self, seqid, iprot, oprot):
        args = quireBusinessInfo_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireBusinessInfo_result()
        try:
            result.success = self._handler.quireBusinessInfo(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireBusinessInfo", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireIpInfo(self, seqid, iprot, oprot):
        args = quireIpInfo_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireIpInfo_result()
        try:
            result.success = self._handler.quireIpInfo(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireIpInfo", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireProcInfo(self, seqid, iprot, oprot):
        args = quireProcInfo_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireProcInfo_result()
        try:
            result.success = self._handler.quireProcInfo(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireProcInfo", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireSystem(self, seqid, iprot, oprot):
        args = quireSystem_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireSystem_result()
        try:
            result.success = self._handler.quireSystem(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireSystem", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireCpu(self, seqid, iprot, oprot):
        args = quireCpu_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireCpu_result()
        try:
            result.success = self._handler.quireCpu(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireCpu", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireMem(self, seqid, iprot, oprot):
        args = quireMem_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireMem_result()
        try:
            result.success = self._handler.quireMem(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireMem", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireNet(self, seqid, iprot, oprot):
        args = quireNet_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireNet_result()
        try:
            result.success = self._handler.quireNet(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireNet", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireDisk(self, seqid, iprot, oprot):
        args = quireDisk_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireDisk_result()
        try:
            result.success = self._handler.quireDisk(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireDisk", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireDiskUsed(self, seqid, iprot, oprot):
        args = quireDiskUsed_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireDiskUsed_result()
        try:
            result.success = self._handler.quireDiskUsed(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireDiskUsed", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireProcess(self, seqid, iprot, oprot):
        args = quireProcess_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireProcess_result()
        try:
            result.success = self._handler.quireProcess(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireProcess", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireLocalInfo(self, seqid, iprot, oprot):
        args = quireLocalInfo_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireLocalInfo_result()
        try:
            result.success = self._handler.quireLocalInfo(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireLocalInfo", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireArch(self, seqid, iprot, oprot):
        args = quireArch_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireArch_result()
        try:
            result.success = self._handler.quireArch(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireArch", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireCroud(self, seqid, iprot, oprot):
        args = quireCroud_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireCroud_result()
        try:
            result.success = self._handler.quireCroud(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireCroud", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireIpTable(self, seqid, iprot, oprot):
        args = quireIpTable_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireIpTable_result()
        try:
            result.success = self._handler.quireIpTable(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireIpTable", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireAlarm(self, seqid, iprot, oprot):
        args = quireAlarm_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireAlarm_result()
        try:
            result.success = self._handler.quireAlarm(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireAlarm", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireAllProc(self, seqid, iprot, oprot):
        args = quireAllProc_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireAllProc_result()
        try:
            result.success = self._handler.quireAllProc(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireAllProc", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireAllPort(self, seqid, iprot, oprot):
        args = quireAllPort_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireAllPort_result()
        try:
            result.success = self._handler.quireAllPort(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireAllPort", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireMultiInfos(self, seqid, iprot, oprot):
        args = quireMultiInfos_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireMultiInfos_result()
        try:
            result.success = self._handler.quireMultiInfos(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireMultiInfos", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireHistoryCpu(self, seqid, iprot, oprot):
        args = quireHistoryCpu_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireHistoryCpu_result()
        try:
            result.success = self._handler.quireHistoryCpu(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireHistoryCpu", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireHistoryMem(self, seqid, iprot, oprot):
        args = quireHistoryMem_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireHistoryMem_result()
        try:
            result.success = self._handler.quireHistoryMem(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireHistoryMem", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireHistoryNet(self, seqid, iprot, oprot):
        args = quireHistoryNet_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireHistoryNet_result()
        try:
            result.success = self._handler.quireHistoryNet(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireHistoryNet", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireHistoryDisk(self, seqid, iprot, oprot):
        args = quireHistoryDisk_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireHistoryDisk_result()
        try:
            result.success = self._handler.quireHistoryDisk(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireHistoryDisk", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireHistoryDiskUsed(self, seqid, iprot, oprot):
        args = quireHistoryDiskUsed_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireHistoryDiskUsed_result()
        try:
            result.success = self._handler.quireHistoryDiskUsed(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireHistoryDiskUsed", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireHistoryProcess(self, seqid, iprot, oprot):
        args = quireHistoryProcess_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireHistoryProcess_result()
        try:
            result.success = self._handler.quireHistoryProcess(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireHistoryProcess", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireHistoryLocalInfo(self, seqid, iprot, oprot):
        args = quireHistoryLocalInfo_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireHistoryLocalInfo_result()
        try:
            result.success = self._handler.quireHistoryLocalInfo(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireHistoryLocalInfo", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireHistoryArch(self, seqid, iprot, oprot):
        args = quireHistoryArch_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireHistoryArch_result()
        try:
            result.success = self._handler.quireHistoryArch(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireHistoryArch", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireHistoryCroud(self, seqid, iprot, oprot):
        args = quireHistoryCroud_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireHistoryCroud_result()
        try:
            result.success = self._handler.quireHistoryCroud(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireHistoryCroud", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireHistoryIpTable(self, seqid, iprot, oprot):
        args = quireHistoryIpTable_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireHistoryIpTable_result()
        try:
            result.success = self._handler.quireHistoryIpTable(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireHistoryIpTable", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireHistoryAlarm(self, seqid, iprot, oprot):
        args = quireHistoryAlarm_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireHistoryAlarm_result()
        try:
            result.success = self._handler.quireHistoryAlarm(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireHistoryAlarm", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireHistoryAllProc(self, seqid, iprot, oprot):
        args = quireHistoryAllProc_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireHistoryAllProc_result()
        try:
            result.success = self._handler.quireHistoryAllProc(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireHistoryAllProc", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireHistoryAllPort(self, seqid, iprot, oprot):
        args = quireHistoryAllPort_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireHistoryAllPort_result()
        try:
            result.success = self._handler.quireHistoryAllPort(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireHistoryAllPort", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireLostAgentInfo(self, seqid, iprot, oprot):
        args = quireLostAgentInfo_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireLostAgentInfo_result()
        try:
            result.success = self._handler.quireLostAgentInfo(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireLostAgentInfo", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireAgentStatus(self, seqid, iprot, oprot):
        args = quireAgentStatus_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireAgentStatus_result()
        try:
            result.success = self._handler.quireAgentStatus(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireAgentStatus", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireAllIp(self, seqid, iprot, oprot):
        args = quireAllIp_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireAllIp_result()
        try:
            result.success = self._handler.quireAllIp()
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireAllIp", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_quireMultiIp(self, seqid, iprot, oprot):
        args = quireMultiIp_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = quireMultiIp_result()
        try:
            result.success = self._handler.quireMultiIp(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("quireMultiIp", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_flushAgentInfo(self, seqid, iprot, oprot):
        args = flushAgentInfo_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = flushAgentInfo_result()
        try:
            result.success = self._handler.flushAgentInfo(args.requestInfo)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("flushAgentInfo", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_agent_status(self, seqid, iprot, oprot):
        args = get_agent_status_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_agent_status_result()
        try:
            result.success = self._handler.get_agent_status(args.request_info)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("get_agent_status", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_agent_info(self, seqid, iprot, oprot):
        args = get_agent_info_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_agent_info_result()
        try:
            result.success = self._handler.get_agent_info(args.request_info)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error")
        oprot.writeMessageBegin("get_agent_info", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()


# HELPER FUNCTIONS AND STRUCTURES


class quireBusinessInfo_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireBusinessInfo_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireBusinessInfo_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireBusinessInfo_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireIpInfo_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireIpInfo_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireIpInfo_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireIpInfo_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireProcInfo_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireProcInfo_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireProcInfo_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireProcInfo_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireSystem_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireSystem_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireSystem_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireSystem_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireCpu_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireCpu_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireCpu_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireCpu_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireMem_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireMem_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireMem_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireMem_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireNet_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireNet_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireNet_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireNet_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireDisk_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireDisk_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireDisk_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireDisk_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireDiskUsed_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireDiskUsed_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireDiskUsed_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireDiskUsed_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireProcess_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireProcess_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireProcess_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireProcess_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireLocalInfo_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireLocalInfo_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireLocalInfo_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireLocalInfo_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireArch_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireArch_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireArch_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireArch_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireCroud_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireCroud_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireCroud_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireCroud_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireIpTable_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireIpTable_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireIpTable_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireIpTable_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireAlarm_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireAlarm_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireAlarm_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireAlarm_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireAllProc_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireAllProc_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireAllProc_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireAllProc_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireAllPort_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireAllPort_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireAllPort_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireAllPort_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireMultiInfos_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (RequestInfo, RequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = RequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireMultiInfos_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireMultiInfos_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireMultiInfos_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryCpu_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (CacheHistoryInfo, CacheHistoryInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = CacheHistoryInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryCpu_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryCpu_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryCpu_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryMem_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (CacheHistoryInfo, CacheHistoryInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = CacheHistoryInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryMem_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryMem_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryMem_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryNet_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (CacheHistoryInfo, CacheHistoryInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = CacheHistoryInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryNet_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryNet_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryNet_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryDisk_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (CacheHistoryInfo, CacheHistoryInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = CacheHistoryInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryDisk_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryDisk_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryDisk_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryDiskUsed_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (CacheHistoryInfo, CacheHistoryInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = CacheHistoryInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryDiskUsed_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryDiskUsed_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryDiskUsed_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryProcess_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (CacheHistoryInfo, CacheHistoryInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = CacheHistoryInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryProcess_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryProcess_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryProcess_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryLocalInfo_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (CacheHistoryInfo, CacheHistoryInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = CacheHistoryInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryLocalInfo_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryLocalInfo_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryLocalInfo_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryArch_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (CacheHistoryInfo, CacheHistoryInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = CacheHistoryInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryArch_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryArch_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryArch_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryCroud_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (CacheHistoryInfo, CacheHistoryInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = CacheHistoryInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryCroud_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryCroud_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryCroud_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryIpTable_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (CacheHistoryInfo, CacheHistoryInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = CacheHistoryInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryIpTable_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryIpTable_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryIpTable_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryAlarm_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (CacheHistoryInfo, CacheHistoryInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = CacheHistoryInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryAlarm_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryAlarm_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryAlarm_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryAllProc_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (CacheHistoryInfo, CacheHistoryInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = CacheHistoryInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryAllProc_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryAllProc_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryAllProc_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryAllPort_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (CacheHistoryInfo, CacheHistoryInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = CacheHistoryInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryAllPort_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireHistoryAllPort_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (ResponseInfo, ResponseInfo.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ResponseInfo()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireHistoryAllPort_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireLostAgentInfo_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (LostAgentInfo, LostAgentInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = LostAgentInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireLostAgentInfo_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireLostAgentInfo_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (LostAgentResponse, LostAgentResponse.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = LostAgentResponse()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireLostAgentInfo_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireAgentStatus_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (AgentStatusRequestInfo, AgentStatusRequestInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = AgentStatusRequestInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireAgentStatus_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireAgentStatus_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (AgentStatusResponse, AgentStatusResponse.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = AgentStatusResponse()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireAgentStatus_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireAllIp_args(object):

    thrift_spec = ()

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireAllIp_args")
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireAllIp_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (MultiResponse, MultiResponse.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = MultiResponse()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireAllIp_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireMultiIp_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (MultipleBzIdIp, MultipleBzIdIp.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = MultipleBzIdIp()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireMultiIp_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class quireMultiIp_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (MultiResponse, MultiResponse.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = MultiResponse()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("quireMultiIp_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class flushAgentInfo_args(object):
    """
    Attributes:
     - requestInfo
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "requestInfo",
            (FlushAgentInfo, FlushAgentInfo.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        requestInfo=None,
    ):
        self.requestInfo = requestInfo

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.requestInfo = FlushAgentInfo()
                    self.requestInfo.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("flushAgentInfo_args")
        if self.requestInfo is not None:
            oprot.writeFieldBegin("requestInfo", TType.STRUCT, 1)
            self.requestInfo.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class flushAgentInfo_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (MultiResponse, MultiResponse.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = MultiResponse()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("flushAgentInfo_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class get_agent_status_args(object):
    """
    Attributes:
     - request_info
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "request_info",
            (agent_status_request, agent_status_request.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        request_info=None,
    ):
        self.request_info = request_info

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.request_info = agent_status_request()
                    self.request_info.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("get_agent_status_args")
        if self.request_info is not None:
            oprot.writeFieldBegin("request_info", TType.STRUCT, 1)
            self.request_info.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class get_agent_status_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (agent_status_response, agent_status_response.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = agent_status_response()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("get_agent_status_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class get_agent_info_args(object):
    """
    Attributes:
     - request_info
    """

    thrift_spec = (
        None,  # 0
        (
            1,
            TType.STRUCT,
            "request_info",
            (agent_status_request, agent_status_request.thrift_spec),
            None,
        ),  # 1
    )

    def __init__(
        self,
        request_info=None,
    ):
        self.request_info = request_info

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.request_info = agent_status_request()
                    self.request_info.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("get_agent_info_args")
        if self.request_info is not None:
            oprot.writeFieldBegin("request_info", TType.STRUCT, 1)
            self.request_info.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class get_agent_info_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (
            0,
            TType.STRUCT,
            "success",
            (agent_status_response, agent_status_response.thrift_spec),
            None,
        ),  # 0
    )

    def __init__(
        self,
        success=None,
    ):
        self.success = success

    def read(self, iprot):
        if (
            iprot._fast_decode is not None
            and isinstance(iprot.trans, TTransport.CReadableTransport)
            and self.thrift_spec is not None
        ):
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = agent_status_response()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin("get_agent_info_result")
        if self.success is not None:
            oprot.writeFieldBegin("success", TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ["%s=%r" % (key, value) for key, value in self.__dict__.items()]
        return "%s(%s)" % (self.__class__.__name__, ", ".join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
